package com.malou.client.ventas.modeloprenda;

import java.util.ArrayList;
import java.util.List;

import com.extjs.gxt.ui.client.Style.HorizontalAlignment;
import com.extjs.gxt.ui.client.data.BeanModel;
import com.extjs.gxt.ui.client.data.BeanModelFactory;
import com.extjs.gxt.ui.client.data.BeanModelLookup;
import com.extjs.gxt.ui.client.event.ButtonEvent;
import com.extjs.gxt.ui.client.event.ComponentEvent;
import com.extjs.gxt.ui.client.event.Events;
import com.extjs.gxt.ui.client.event.KeyListener;
import com.extjs.gxt.ui.client.event.Listener;
import com.extjs.gxt.ui.client.event.SelectionChangedEvent;
import com.extjs.gxt.ui.client.event.SelectionChangedListener;
import com.extjs.gxt.ui.client.event.SelectionListener;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.util.IconHelper;
import com.extjs.gxt.ui.client.widget.Component;
import com.extjs.gxt.ui.client.widget.ContentPanel;
import com.extjs.gxt.ui.client.widget.Dialog;
import com.extjs.gxt.ui.client.widget.LayoutContainer;
import com.extjs.gxt.ui.client.widget.MessageBox;
import com.extjs.gxt.ui.client.widget.Status;
import com.extjs.gxt.ui.client.widget.button.Button;
import com.extjs.gxt.ui.client.widget.form.ComboBox;
import com.extjs.gxt.ui.client.widget.form.FieldSet;
import com.extjs.gxt.ui.client.widget.form.FormPanel;
import com.extjs.gxt.ui.client.widget.form.HiddenField;
import com.extjs.gxt.ui.client.widget.form.NumberField;
import com.extjs.gxt.ui.client.widget.form.TextField;
import com.extjs.gxt.ui.client.widget.form.ComboBox.TriggerAction;
import com.extjs.gxt.ui.client.widget.form.FormPanel.LabelAlign;
import com.extjs.gxt.ui.client.widget.grid.CellEditor;
import com.extjs.gxt.ui.client.widget.grid.ColumnConfig;
import com.extjs.gxt.ui.client.widget.grid.ColumnModel;
import com.extjs.gxt.ui.client.widget.grid.EditorGrid;
import com.extjs.gxt.ui.client.widget.grid.Grid;
import com.extjs.gxt.ui.client.widget.grid.GridSelectionModel;
import com.extjs.gxt.ui.client.widget.grid.RowNumberer;
import com.extjs.gxt.ui.client.widget.layout.ColumnData;
import com.extjs.gxt.ui.client.widget.layout.ColumnLayout;
import com.extjs.gxt.ui.client.widget.layout.FitLayout;
import com.extjs.gxt.ui.client.widget.layout.FormData;
import com.extjs.gxt.ui.client.widget.layout.FormLayout;
import com.extjs.gxt.ui.client.widget.toolbar.FillToolItem;
import com.extjs.gxt.ui.client.widget.toolbar.ToolBar;
import com.google.gwt.core.client.GWT;
import com.google.gwt.event.dom.client.KeyCodes;
import com.malou.client.MalouConstants;
import com.malou.client.util.Utilities;
import com.malou.client.ventas.cambio.Cambio;
import com.malou.client.ventas.ingresostock.IngresoStock;
import com.malou.client.ventas.salidastock.SalidaStock;

public class IngresoaOfertaDialog extends Dialog{
	private   Button guardar;
	private   Button cancelar;
	public    Status status;
	private   MalouConstants constants = GWT.create(MalouConstants.class);
	
	public    TextField<String> codigoingreso;
	public    HiddenField<String> prendaingreso_id;
	public    ComboBox<BeanModel> prendaingreso;
	public    NumberField cantidad_ingreso;
	public    NumberField stockingreso;
	
	public    TextField<String> codigosalida;
	public    HiddenField<String> prendasalida_id;
	public    ComboBox<BeanModel> prendasalida;	
	public    NumberField cantidad_salida;
	public    NumberField stocksalida;
	
	IngresoStock ins;
	SalidaStock  sal;
	Cambio cam;
		
	private Button delDetalle_ingreso;
	private Button delDetalle_salida;
		
	protected static ListStore<BeanModel> store_ingreso;
	private ListStore<BeanModel> store_salida;
	private ListStore<BeanModel> store_salida_2;
	
	public  Grid<BeanModel> grid_ingreso;
	public  Grid<BeanModel> grid_salida;

	private ToolBar toolBar_ingreso;
    private ToolBar toolBar_salida;
    
	private FormPanel panel;
	
	
	public IngresoaOfertaDialog(){
		setLayout(new FitLayout());
		setIcon(IconHelper.createPath("images/icons/addOffer.png"));
		setModal(true);
		setPlain(true);
		setSize(800, 500);
		setClosable(true);
	
		ModeloPrendas.ingresoaofertaDialog = this;
		
		panel = new FormPanel();		
		panel.setBorders(false);
	    panel.setBodyBorder(false);
	    panel.setPadding(5);
	    panel.setHeaderVisible(false);
		
	    addFields(panel);
		    
	    setButtonAlign(HorizontalAlignment.LEFT);
	    setButtons("");
	    add(panel);
	 
	    setBodyBorder(true);	    
	    setResizable(false);	    
	    setFocusWidget(codigoingreso);
	    	    
		setHeading(constants.ingresoaOferta());

	}
	
	private void addFields(FormPanel cp) {
	
		ModeloPrendas.autoComplete();
		ModeloPrendas.autoCompleteIngreso();
		ModeloPrendas.autoCompleteSalida();
		
	    
		FieldSet ingresoFieldSet = new FieldSet();
		ingresoFieldSet.setHeading(constants.prendasingreso());
		ingresoFieldSet.setLayout(new ColumnLayout());
		ingresoFieldSet.setStyleAttribute("marginTop", "8px");
		ingresoFieldSet.setStyleAttribute("padding", "8px");
		ingresoFieldSet.setBorders(true);


		FieldSet salidaFieldSet = new FieldSet();
		salidaFieldSet.setHeading(constants.prendaoferta());
		salidaFieldSet.setLayout(new ColumnLayout());
		salidaFieldSet.setStyleAttribute("marginTop", "8px");
		salidaFieldSet.setStyleAttribute("padding", "8px");
		salidaFieldSet.setBorders(true);

		stockingreso = new NumberField();
		stockingreso.setFieldLabel(constants.stock());
	    stockingreso.setWidth(20);
		stockingreso.setAllowNegative(false);
		stockingreso.setAllowBlank(false);
		stockingreso.setAllowDecimals(false);
		
		
		stocksalida = new NumberField();
		stocksalida.setFieldLabel(constants.stock());
		stocksalida.setWidth(20);
	    stocksalida.setAllowNegative(false);
		stocksalida.setAllowBlank(false);
		stocksalida.setAllowDecimals(false);


		toolBar_ingreso = new ToolBar();
		toolBar_salida = new ToolBar();

		store_ingreso = new ListStore<BeanModel>();
		
    	store_salida  = new ListStore<BeanModel>();
    	store_salida_2 = new ListStore<BeanModel>();
			   	
		prendaingreso_id = new HiddenField<String>();
		
		codigoingreso = new TextField<String>();
		codigoingreso.setFieldLabel(constants.codigo());	
		codigoingreso.setAllowBlank(false);
		codigoingreso.setWidth(20);
		codigoingreso.addKeyListener(new KeyListener(){
		public void componentKeyDown(ComponentEvent event){
			if(event.getKeyCode() == KeyCodes.KEY_ENTER){
				if(codigoingreso.getValue() != null){
					ModeloPrendas.getPrendaIngresoaOferta(codigoingreso.getValue());
			     }
			   }				
			}
		});
		
		prendaingreso = new ComboBox<BeanModel>();
		prendaingreso.setFieldLabel(constants.prenda());
		prendaingreso.setDisplayField("nombre");			 	    
		prendaingreso.setStore(ModeloPrendas.storeAutocompleteingreso);		
		prendaingreso.setValueField("nombre");
		prendaingreso.setHideTrigger(true);  
		prendaingreso.setPageSize(10);
		prendaingreso.setUseQueryCache(false);
		prendaingreso.setTriggerAction(TriggerAction.ALL);
		prendaingreso.setAllowBlank(false);
		
		prendaingreso.addSelectionChangedListener(new SelectionChangedListener<BeanModel>() {
			
			@Override
			public void selectionChanged(SelectionChangedEvent<BeanModel> se) {
				if(se.getSelectedItem() != null){
				codigoingreso.setValue(se.getSelectedItem().get("codigo").toString());
				prendaingreso_id.setValue(se.getSelectedItem().get("id").toString());
				cantidad_ingreso.setValue(1);
				stockingreso.setValue(Integer.parseInt(se.getSelectedItem().get("stock").toString()));
				}
			}
		});
		
		
		cantidad_ingreso = new NumberField();
		cantidad_ingreso.setFieldLabel(constants.cantidad());		
		cantidad_ingreso.setAllowNegative(false);
		cantidad_ingreso.setAllowBlank(false);
		cantidad_ingreso.setAllowDecimals(false);
		cantidad_ingreso.setPropertyEditorType(Integer.class);
		cantidad_ingreso.setMinValue(1);
		
		cantidad_ingreso.addKeyListener(new KeyListener() {

			public void componentKeyDown(ComponentEvent event) {
				if (event.getKeyCode() == KeyCodes.KEY_ENTER) {
					agregarDetalleIngreso();
					
				}
			}
		});

		
		delDetalle_ingreso = new Button(constants.eliminar(), IconHelper.createPath("images/icons/delete.gif"));
	    delDetalle_ingreso.setEnabled(false);
	    
        SelectionListener<ButtonEvent> sl_deling;        
        sl_deling = new SelectionListener<ButtonEvent>(){
        	
        	@Override
			public void componentSelected(ButtonEvent ce) {		
				BeanModel be =grid_ingreso.getSelectionModel().getSelectedItem();
				grid_ingreso.getStore().remove(be);
				BeanModel bm = store_salida.getModels().get(0);
				store_salida.getRecord(bm).set("cantidad_salida", calcularSumIngreso(store_ingreso));
				store_salida.commitChanges();
			}
        };
        delDetalle_ingreso.addSelectionListener(sl_deling);
        
      
        
        prendasalida_id  = new HiddenField<String>();
    	        
		codigosalida = new TextField<String>();
		codigosalida.setFieldLabel(constants.codigo());
		codigosalida.setAllowBlank(false);
		codigosalida.setWidth(20);
		codigosalida.addKeyListener(new KeyListener(){
			public void componentKeyDown(ComponentEvent event){
				if(event.getKeyCode() == KeyCodes.KEY_ENTER){
					if(codigosalida.getValue() != null){
							cantidad_salida.setValue(calcularSumIngreso(store_ingreso));
							ModeloPrendas.getPrendaSalidaaOferta(codigosalida.getValue());
						}
				}				
			}
		});
		
		prendasalida = new ComboBox<BeanModel>();
		prendasalida.setFieldLabel(constants.prenda());
		prendasalida.setDisplayField("nombre");			 	    
		prendasalida.setStore(ModeloPrendas.storeAutocompletesalida);		
		prendasalida.setValueField("nombre");
		prendasalida.setHideTrigger(true);  
		prendasalida.setPageSize(10);
		prendasalida.setUseQueryCache(false);
		prendasalida.setTriggerAction(TriggerAction.ALL);
		prendasalida.setAllowBlank(false);
		
		prendasalida.addSelectionChangedListener(new SelectionChangedListener<BeanModel>() {
			
			@Override
			public void selectionChanged(SelectionChangedEvent<BeanModel> se) {
				if(se.getSelectedItem() != null){
				codigosalida.setValue(se.getSelectedItem().get("codigo").toString());
				prendasalida_id.setValue(se.getSelectedItem().get("id").toString());
				cantidad_salida.setValue(calcularSumIngreso(store_ingreso));
				stocksalida.setValue(Integer.parseInt(se.getSelectedItem().get("stock").toString()));
				}
			}
		});
		
		cantidad_salida = new NumberField();
		cantidad_salida.setFieldLabel(constants.cantidad());		
		cantidad_salida.setAllowNegative(false);
		cantidad_salida.setAllowBlank(false);
		cantidad_salida.setAllowDecimals(false);
		cantidad_salida.setPropertyEditorType(Integer.class);
		cantidad_salida.setMinValue(1);
		
		cantidad_salida.addKeyListener(new KeyListener() {

			public void componentKeyDown(ComponentEvent event) {
				if (event.getKeyCode() == KeyCodes.KEY_ENTER) {
					agregarDetalleSalida();
				}
			}
		});
	
		ingresoFieldSet.add(setLayout(codigoingreso, "98%",50),	new ColumnData(.25));
		ingresoFieldSet.add(setLayout(prendaingreso, "93%", 50),new ColumnData(.35));
		ingresoFieldSet.add(setLayout(cantidad_ingreso, "85%", 50),new ColumnData(.20));
		ingresoFieldSet.add(setLayout(stockingreso, "85%", 50),new ColumnData(.20));
	    
		salidaFieldSet.add(setLayout(codigosalida, "98%", 50), new ColumnData(.25));
		salidaFieldSet.add(setLayout(prendasalida, "93%", 50),new ColumnData(.35));
		salidaFieldSet.add(setLayout(cantidad_salida, "85%", 50),new ColumnData(.20));
		salidaFieldSet.add(setLayout(stocksalida, "85%", 50),new ColumnData(.20));

			
		delDetalle_salida = new Button(constants.eliminar(), IconHelper.createPath("images/icons/delete.gif"));
	    delDetalle_salida.setEnabled(false);
	    
        SelectionListener<ButtonEvent> sl_delsal;        
        sl_delsal = new SelectionListener<ButtonEvent>(){
        	
        	@Override
			public void componentSelected(ButtonEvent ce) {		
				BeanModel be =grid_salida.getSelectionModel().getSelectedItem();
				grid_salida.getStore().remove(be);
			}
        };
        delDetalle_salida.addSelectionListener(sl_delsal);
        
        toolBar_ingreso.add(delDetalle_ingreso);
		toolBar_salida.add(delDetalle_salida);
		
	        
	    ArrayList<ColumnConfig> colum_ingreso = new ArrayList<ColumnConfig>();
	    ColumnConfig column = new ColumnConfig();
		
	    RowNumberer ri = new RowNumberer();
		   
	    colum_ingreso.add(ri);
	    colum_ingreso.add(new ColumnConfig("codigoingreso", constants.codigo(), 200));
	    colum_ingreso.add(new ColumnConfig("prendaingreso", constants.prenda(),300));

		column = new ColumnConfig("cantidad_ingreso", constants.cantidad(), 100);
		column.setAlignment(HorizontalAlignment.RIGHT);

			NumberField cantidad_ingreso = new NumberField();
			cantidad_ingreso.setAllowBlank(false);
			cantidad_ingreso.setPropertyEditorType(Double.class);
			cantidad_ingreso.setAllowNegative(false);
			column.setEditor(new CellEditor(cantidad_ingreso));
		colum_ingreso.add(column);

	    column = new ColumnConfig("stockingreso",constants.stock(),100);
	    column.setAlignment(HorizontalAlignment.RIGHT);
	    colum_ingreso.add(column);    
		       
        ColumnModel cmi = new ColumnModel(colum_ingreso);       
        
        grid_ingreso = new EditorGrid<BeanModel>(store_ingreso, cmi);
        grid_ingreso.addPlugin(ri); 
        grid_ingreso.setSelectionModel(new GridSelectionModel<BeanModel>());
        grid_ingreso.getSelectionModel().addListener(Events.SelectionChange, new Listener<SelectionChangedEvent<BeanModel>>(){

			@Override
			public void handleEvent(SelectionChangedEvent<BeanModel> be) {				
				if(be.getSelectedItem() != null)
					delDetalle_ingreso.setEnabled(true);
				else
					delDetalle_ingreso.setEnabled(false);
			}
		});

        ArrayList<ColumnConfig> colum_salida = new ArrayList<ColumnConfig>();
        ColumnConfig cc = new ColumnConfig();
	    RowNumberer rs = new RowNumberer();
	    
	    colum_salida.add(rs);
	    colum_salida.add(new ColumnConfig("codigosalida", constants.codigo(), 200));
	    colum_salida.add(new ColumnConfig("prendasalida", constants.prenda(),300));
	    
	    cc = new ColumnConfig("cantidad_salida",constants.cantidad(),100);
	    cc.setAlignment(HorizontalAlignment.RIGHT);
	    colum_salida.add(cc);
	    
	    cc = new ColumnConfig("stocksalida",constants.stock(),100);
	    cc.setAlignment(HorizontalAlignment.RIGHT);
	    colum_salida.add(cc);
			       
        ColumnModel cms = new ColumnModel(colum_salida);      
        
        
        grid_salida = new Grid<BeanModel>(store_salida, cms);
        grid_salida.addPlugin(rs);  
        grid_salida.getSelectionModel().addListener(Events.SelectionChange, new Listener<SelectionChangedEvent<BeanModel>>(){

			@Override
			public void handleEvent(SelectionChangedEvent<BeanModel> be) {				
				if(be.getSelectedItem() != null)
					delDetalle_salida.setEnabled(true);
				else
					delDetalle_salida.setEnabled(false);
			}
		});

        
        ContentPanel detalle_ingreso = new ContentPanel();
        detalle_ingreso.setHeaderVisible(false);
        detalle_ingreso.setLayout(new FitLayout());
        detalle_ingreso.setHeight(130);
        detalle_ingreso.add(grid_ingreso);
        detalle_ingreso.setTopComponent(toolBar_ingreso);        
        
        ContentPanel detalle_salida = new ContentPanel();
        detalle_salida.setHeaderVisible(false);
        detalle_salida.setLayout(new FitLayout());
        detalle_salida.setHeight(130);
        detalle_salida.add(grid_salida);
        detalle_salida.setTopComponent(toolBar_salida);       
        
		Component comp[]={codigoingreso,prendaingreso,this.cantidad_ingreso,codigosalida,prendasalida,cantidad_salida};
		Utilities.Enter(comp);
		
        cp.add(ingresoFieldSet);
        cp.add(detalle_ingreso);
        cp.add(salidaFieldSet);
        cp.add(detalle_salida);
	}
	
	public Integer calcularSumIngreso(ListStore<BeanModel> storeingreso){
		Integer cant_i=0;
		if(store_ingreso.getModels().size()>0){
			for(BeanModel bm:storeingreso.getModels())
				cant_i += Integer.valueOf(bm.get("cantidad_ingreso").toString());
		}

		return cant_i;
	}
	
	
	
	@Override
	  protected void createButtons() {
	    super.createButtons();
	    
	    if (constants == null) {
	    	constants = GWT.create(MalouConstants.class);
		}
	    
	    status = new Status();
	    status.setBusy(constants.guardando());
	    status.hide();
	    status.setAutoWidth(true);
	    getButtonBar().add(status);
	    
	    getButtonBar().add(new FillToolItem());
	    
	    cancelar = new Button(constants.cancelar());
	    
	    cancelar.addSelectionListener(new SelectionListener<ButtonEvent>() {
	      public void componentSelected(ButtonEvent ce) {	    	  
	    	  IngresoaOfertaDialog.this.hide();
	      }

	    });

	    guardar = new Button(constants.guardar());
	    
	    
	    guardar.addSelectionListener(new SelectionListener<ButtonEvent>() {
	      public void componentSelected(ButtonEvent ce) {
	    	  if(validarPrincipal()){
	    		  cam = new Cambio();
	    		  
	    		  status.show();
	    		  getButtonBar().disable();
	    		  
	    		  List<IngresoStock> listIngreso = new ArrayList<IngresoStock>(); 
	    		  List<SalidaStock> listSalida = new ArrayList<SalidaStock>();
	    			 		  
	    		  for(BeanModel bi:store_ingreso.getModels()){
	    			  ins = new IngresoStock(); 
	  
	    			  ins.setModeloprenda_id(Integer.valueOf(bi.get("prendaingreso_id").toString()));
	    			  ins.setCantidad(Integer.valueOf(bi.get("cantidad_ingreso").toString()));
	    			  
	    			  listIngreso.add(ins);
	    		  }	    		  
	    		  
	    		  for(BeanModel bs:store_salida.getModels()){
	    			  sal = new SalidaStock(); 
	  
	    			  sal.setModeloprenda_id(Integer.valueOf(bs.get("prendasalida_id").toString()));
	    			  sal.setCantidad(Integer.valueOf(bs.get("cantidad_salida").toString()));
	    			  
	    			  listSalida.add(sal);
	    		  }
	    			  
	    		  ModeloPrendas.ingresoaofertaDialog = IngresoaOfertaDialog.this;
	    		  ModeloPrendas.save(listIngreso,listSalida);
	    		  clearPrincipal();
	    	  }	    	  
	      }
	    });
	    
	    addButton(guardar);
	    addButton(cancelar);	    
	    
	  }
	

	
	public boolean validarPrincipal(){
    	boolean det = true;
		if(store_ingreso.getCount()==0 || store_salida.getCount()==0){
			det = false;
			MessageBox.alert(constants.sistemaMarcocruzado(), constants.detallesRequeridos(), null);
		}
		codigoingreso.setAllowBlank(true);
		cantidad_ingreso.setAllowBlank(true);
		codigosalida.setAllowBlank(true);
		cantidad_salida.setAllowBlank(true);
		
		return det;
	}
	
	public void clearDetalle(){
	    codigosalida.clear();
		prendasalida.clear();
		cantidad_salida.clear();
		stocksalida.clear();
		codigoingreso.clear();
		prendaingreso.clear();
		cantidad_ingreso.clear();
		stockingreso.clear();
	}
	
	public void clearPrincipal(){
		store_ingreso.removeAll();
		store_salida.removeAll();
		clearDetalle();
	 }
	
	
	public void agregarDetalleIngreso(){
		
	  Boolean add = true;
	  if(validarIngreso()){	 
  	   if(store_ingreso.getCount() > 0 ){
  		  String pi_id = prendaingreso_id.getValue();
  		  Integer cant_i = Integer.valueOf(cantidad_ingreso.getValue().toString());
  		  
  		  String pidetalle_id;
  		  Integer cantdetalle;
  		  for(BeanModel b:store_ingreso.getModels()){
  			pidetalle_id = b.get("prendaingreso_id").toString();
  			  
  			  if(pidetalle_id.equals(pi_id)){
  				  
  				  add = false;	    				
  				  cantdetalle = b.get("cantidad_ingreso");
  				  store_ingreso.getRecord(b).set("cantidad_ingreso", cantdetalle+cant_i);
  				  store_ingreso.commitChanges();
  				  clearDetalle();
  				  codigoingreso.focus();
  				  break;
  			  }
  		  }
	
  	  }
		if(add){
		   		  Cambio c = new Cambio();
	    		  c.setPrendaingreso_id(Integer.valueOf(prendaingreso_id.getValue()));
	    		  c.setCodigoingreso(codigoingreso.getValue());
	    		  c.setPrendaingreso(prendaingreso.getRawValue());
	    		  c.setCantidad_ingreso(cantidad_ingreso.getValue().intValue());
	    		  c.setStockingreso(stockingreso.getValue().intValue());
		    	  BeanModelFactory beanModelFactory =  BeanModelLookup.get().getFactory(c.getClass());
		    	  store_ingreso.add(beanModelFactory.createModel(c));
		    	  clearDetalle();
	    	      codigoingreso.focus();
 	   }
	  }	
	}
	
	public void agregarDetalleSalida(){
		
	  if(validarSalida()){	 
  			
   		  Cambio c = new Cambio();
		  c.setPrendasalida_id(Integer.valueOf(prendasalida_id.getValue()));
		  c.setCodigosalida(codigosalida.getValue());
		  c.setPrendasalida(prendasalida.getRawValue().toString());
		  c.setCantidad_salida(cantidad_salida.getValue().intValue());
    	  c.setStocksalida(stocksalida.getValue().intValue());
    	  BeanModelFactory beanModelFactory =  BeanModelLookup.get().getFactory(c.getClass());
    	  store_salida_2.add(beanModelFactory.createModel(c));
    	  
    	  if(store_salida.getModels().size()>0)
    		  store_salida.removeAll();
    	  
    	  store_salida.add(store_salida_2.getModels());
    	  
    	  store_salida_2.removeAll();
    	  clearDetalle();
	      codigoingreso.focus();
      }	
	}
	

      public Boolean validarIngreso(){
    	  boolean var = true;
    	  
    	  boolean ci  = codigoingreso.isValid();
    	  boolean pi  = prendaingreso.isValid();
    	  boolean cni = cantidad_ingreso.isValid();
    	  boolean sts = stockingreso.isValid();
    	  
    	  var = ci&&pi&&cni&&sts;
    	  
    	  if(var){
    	   Integer ss = store_salida.getModels().size();
    	   Integer cant_i = cantidad_ingreso.getValue().intValue();
    	   Integer stck_i = stockingreso.getValue().intValue();
    	   
    	   if(stck_i==0){
    		  var=false;
    		  MessageBox.alert("Error Stock", "Stock vacio", null); 
    	   }
    	   if(cant_i>stck_i){
    		  var=false;
              MessageBox.alert("Error Cantidad", "Stock Insuficiente", null);        		  
    	   }
        	 
    	  if(ss>0){
    		  for(BeanModel bm:store_salida.getModels()){
    			  if(codigoingreso.getValue().equals(bm.get("codigosalida").toString())){
    				 var=false;
    				 MessageBox.alert("Error prenda duplicada", "Ya existe esta prenda", null);
    			  }
    	       }		  
    	   }
   	      }
    	return var;
      }
      
      
      public Boolean validarSalida(){
    	  boolean var = true;
   	  
    	  boolean cs  = codigosalida.isValid();
    	  boolean ps  = prendasalida.isValid();
    	  boolean cns = cantidad_salida.isValid();
    	  boolean st  = stocksalida.isValid();
    	  var = cs&&ps&&cns&&st;

    	  if(var){
    	    Integer si = store_ingreso.getModels().size();
    	    Integer cant_s = cantidad_salida.getValue().intValue();
     	    Integer stck_s = stocksalida.getValue().intValue();
     	   
     	    if(stck_s==0){
     		  var=false;
     		  MessageBox.alert("Error Stock", "Stock vacio", null); 
     	    }
     	    if(cant_s>stck_s){
     		  var=false;
              MessageBox.alert("Error Cantidad", "Stock Insuficiente", null);
            }
         	
    	  if(si>0){
    		  for(BeanModel bm:store_ingreso.getModels()){
    			  System.out.println("codigosalida.getValue()"+codigosalida.getValue());
    			  System.out.println("bm.get(codigoingreso).toString()"+bm.get("codigoingreso").toString());
    			  if(codigosalida.getValue().equals(bm.get("codigoingreso").toString())){
    				 var=false;
    	    	     MessageBox.alert("Error prenda duplicada", "Ya existe esta prenda", null);
    			   }
    	       }		  
    	    }
    	  }
    	  
    	  return var;
      }
	
	
	  private LayoutContainer setLayout(Component comp, String porcentaje,Integer withlabel) {
			LayoutContainer layout = new LayoutContainer();
			FormLayout fl = new FormLayout(LabelAlign.LEFT);
			fl.setLabelWidth(withlabel);
			layout.setLayout(fl);
			layout.add(comp, new FormData(porcentaje));

			return layout;
		}
	  
	  protected void clear(){
		  
	  }

}
